let xq_data = []
let xq_ms_12 = []
let xq_ms_3 = []
let xq_k_s = []
if (uni.getStorageSync('questionDesc')) {
	console.log('uni.getStorageSync(questionDesc)', uni.getStorageSync('questionDesc'))
	xq_data = uni.getStorageSync('questionDesc').XQ.xq_data
	xq_ms_12 = uni.getStorageSync('questionDesc').XQ.xq_ms_12
	xq_ms_3 = uni.getStorageSync('questionDesc').XQ.xq_ms_3
	xq_k_s = uni.getStorageSync('questionDesc').XQ.xq_k_s
}


function getFormatBaogao(data) {
	let r_data = {};
	if (data.data == undefined || data.data.length <= 0) {
		return r_data;
	}
	data.data.forEach(item => {
		const t1 = item.t1;
		const t2 = item.t2;
		const v = item.v;

		if (r_data[t1] == undefined) {
			r_data[t1] = {};
		}

		let t1s = r_data[t1];
		let t2v = t1s[t2];
		if (t2v == undefined) {
			t1s[item.t2] = item.v;
		} else {
			t1s[item.t2] = t2v + item.v;
		}

	});

	return r_data;
}
/**
 * 兴趣前三项排序
 * @param {Object} dataXQ
 */
function combinatorialSort(res) {
	const priorityOrder = ['S', 'A', 'E', 'I', 'C', 'R'];

	// 获取第一个元素的类型
	const firstType = res[0].t;

	// 获取第二个和第三个元素的值
	const secondValue = res[1].v;
	const thirdValue = res[2].v;

	// 根据第一个元素的类型确定排序规则
	switch (firstType) {
		case 'S':
			// 如果第一个元素是 S 类型，则根据第二个元素的值进行排序
			if (secondValue === thirdValue) {
				res = [res[0], res[2], res[1], res[3], res[4], res[5]];
			}
			break;
		case 'A':
			// 如果第一个元素是 A 类型，则根据第二个元素的值进行排序
			if (secondValue === thirdValue) {
				res = [res[0], res[2], res[1], res[3], res[4], res[5]];
			}
			break;
		case 'E':
			// 如果第一个元素是 E 类型，则根据第二个元素的类型进行排序
			if (priorityOrder.indexOf(res[2].t) < priorityOrder.indexOf(res[1].t)) {
				res = [res[0], res[2], res[1], res[3], res[4], res[5]];
			}
			break;
		case 'I':
			// 如果第一个元素是 I 类型，则根据第二个元素的类型进行排序
			if (priorityOrder.indexOf(res[2].t) < priorityOrder.indexOf(res[1].t)) {
				res = [res[0], res[2], res[1], res[3], res[4], res[5]];
			}
			break;
		case 'C':
			// 如果第一个元素是 C 类型，则根据第二个元素的类型进行排序
			if (priorityOrder.indexOf(res[2].t) < priorityOrder.indexOf(res[1].t)) {
				res = [res[0], res[2], res[1], res[3], res[4], res[5]];
			}
			break;
		case 'R':
			// 如果第一个元素是 R 类型，则根据第二个元素的类型进行排序
			if (priorityOrder.indexOf(res[2].t) < priorityOrder.indexOf(res[1].t)) {
				res = [res[0], res[2], res[1], res[3], res[4], res[5]];
			}
			break;
		default:
			break;
	}

	return res;
}

// XQ_R 现实型 XQ_I 研究型 XQ_A 艺术型 XQ_S 社会型 XQ_E 企业型 XQ_C 常规型  每种职业兴趣4道题共24道题
function getBaogaoXQ(data) {

	const types = Object.keys(data);
	if (types.length != 6) {
		return;
	}
	let dataXQ = [];

	// 转成数组
	types.forEach(type => {
		dataXQ.push({
			't': type,
			'v': data[type],
			'd': xq_data[type]
		});
	});
	// 根据 V分数 进行排序（降序） 取分数最大的前三项
	dataXQ.sort((a, b) => b.v - a.v);
	dataXQ = combinatorialSort(dataXQ)

	let sxq1 = dataXQ[0];
	let sxq2 = dataXQ[1];
	let sxq3 = dataXQ[2];

	// 类型
	const xq_lx = `${sxq1.t}${sxq2.t}${sxq3.t}(${sxq1.d.n}+${sxq2.d.n}+${sxq3.d.n})`


	// 描述
	const ms_t12 = sxq1.t + sxq2.t;
	const xq_ms = xq_ms_12[ms_t12] + xq_ms_3[sxq3.t];


	let _xq_bq = [];


	dataXQ.forEach(item => {
		let d = item.d;
		d.bq = `${item.t}${item.d.n}`;
		_xq_bq.push(d);
	});
	let categories = [];
	let _data = [];
	let dataObj = {
		"R": 0,
		"I": 0,
		"A": 0,
		"S": 0,
		"E": 0,
		"C": 0,
	}

	dataXQ.forEach(item => {
		dataObj[item.t] = item.v
	})
	let _data_ = []
	for (let i in dataObj) {
		_data_.push(dataObj[i])
	}
	// 六维
	const xq_lw = {
		categories: ["现实型（R）", "研究型（I）", "艺术型（A）", "社会型（S）", "企业型（E）", "常规型（C）"],
		"series": [{
			"name": "你的兴趣维度",
			"data": _data_
		}]
	};

	// 标签
	const xq_bq = _xq_bq;


	return {
		"xq_lx": xq_lx, //类型
		"xq_ms": xq_ms, //描述
		"xq_lw": xq_lw, //图表数据
		"xq_bq": xq_bq,
	};
}
export default {
	getFormatBaogao: getFormatBaogao,
	getBaogaoXQ: getBaogaoXQ,
}